home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Resources / Chat & Communication / Digsby build 37 / digsby_setup.exe / lib / ZSI / dispatch.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2008-10-13  |  8.5 KB  |  295 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. import types
  5. import os
  6. import sys
  7. from BaseHTTPServer import BaseHTTPRequestHandler, HTTPServer
  8. from ZSI import *
  9. from ZSI import _child_elements, _copyright, _seqtypes, _find_arraytype, _find_type, resolvers
  10. from ZSI.auth import _auth_tc, AUTH, ClientBinding
  11. _client_binding = None
  12.  
  13. def GetClientBinding():
  14.     return _client_binding
  15.  
  16.  
  17. gettypecode = lambda mod, e: getattr(mod, str(e.localName)).typecode
  18.  
  19. def _Dispatch(ps, modules, SendResponse, SendFault, nsdict = { }, typesmodule = None, gettypecode = gettypecode, rpc = False, docstyle = False, **kw):
  20.     global _client_binding
  21.     
  22.     try:
  23.         what = str(ps.body_root.localName)
  24.         if modules is None:
  25.             modules = (sys.modules['__main__'],)
  26.         
  27.         handlers = _[1]
  28.         handlers = _[2]
  29.         if len(handlers) > 1:
  30.             raise TypeError('Multiple implementations found: ' + `handlers`)
  31.         
  32.         handler = handlers[0]
  33.         _client_binding = ClientBinding(ps)
  34.         if docstyle:
  35.             result = handler(ps.body_root)
  36.             tc = TC.XML(aslist = 1, pname = what + 'Response')
  37.         elif not rpc:
  38.             
  39.             try:
  40.                 tc = gettypecode(typesmodule, ps.body_root)
  41.             except Exception:
  42.                 tc = TC.Any()
  43.  
  44.             
  45.             try:
  46.                 arg = tc.parse(ps.body_root, ps)
  47.             except EvaluateException:
  48.                 ex = None
  49.                 SendFault(FaultFromZSIException(ex), **kw)
  50.                 return None
  51.  
  52.             
  53.             try:
  54.                 result = handler(arg)
  55.             except Exception:
  56.                 ex = None
  57.                 SendFault(FaultFromZSIException(ex), **kw)
  58.                 return None
  59.  
  60.             
  61.             try:
  62.                 tc = result.typecode
  63.             except AttributeError:
  64.                 ex = None
  65.                 SendFault(FaultFromZSIException(ex), **kw)
  66.                 return None
  67.             except:
  68.                 None<EXCEPTION MATCH>AttributeError
  69.             
  70.  
  71.         None<EXCEPTION MATCH>AttributeError
  72.         if typesmodule is not None:
  73.             kwargs = { }
  74.             for e in _child_elements(ps.body_root):
  75.                 
  76.                 try:
  77.                     tc = gettypecode(typesmodule, e)
  78.                 except Exception:
  79.                     tc = TC.Any()
  80.  
  81.                 
  82.                 try:
  83.                     kwargs[str(e.localName)] = tc.parse(e, ps)
  84.                 continue
  85.                 except EvaluateException:
  86.                     ex = None
  87.                     SendFault(FaultFromZSIException(ex), **kw)
  88.                     return None
  89.                     continue
  90.                 
  91.  
  92.             
  93.             result = handler(**kwargs)
  94.             aslist = False
  95.             if type(result) in _seqtypes:
  96.                 for o in result:
  97.                     aslist = hasattr(result, 'typecode')
  98.                     if aslist:
  99.                         break
  100.                         continue
  101.                     None<EXCEPTION MATCH>EvaluateException
  102.                 
  103.             elif type(result) is not dict:
  104.                 aslist = not hasattr(result, 'typecode')
  105.                 result = (result,)
  106.             
  107.             tc = TC.Any(pname = what + 'Response', aslist = aslist)
  108.         else:
  109.             tp = _find_type(ps.body_root)
  110.             if not type(tp) in (tuple, list) or tp[1] == 'Array':
  111.                 pass
  112.             isarray = _find_arraytype(ps.body_root)
  113.             data = _child_elements(ps.body_root)
  114.             tc = TC.Any()
  115.             if isarray and len(data) == 0:
  116.                 result = handler()
  117.             elif isarray:
  118.                 
  119.                 try:
  120.                     arg = [ tc.parse(e, ps) for e in data ]
  121.                 except EvaluateException:
  122.                     e = None
  123.                     SendFault(RuntimeError('THIS IS AN ARRAY: %s' % isarray))
  124.                     return None
  125.  
  126.                 result = handler(*arg)
  127.             else:
  128.                 
  129.                 try:
  130.                     kwarg = []([ (str(e.localName), tc.parse(e, ps)) for e in data ])
  131.                 except EvaluateException:
  132.                     e = None
  133.                     SendFault(FaultFromZSIException(e), **kw)
  134.                     return None
  135.  
  136.                 result = handler(**kwarg)
  137.             tc = TC.Any(pname = what + 'Response')
  138.         sw = SoapWriter(nsdict = nsdict)
  139.         sw.serialize(result, tc)
  140.         return SendResponse(str(sw), **kw)
  141.     except Fault:
  142.         e = None
  143.         return SendFault(e, **kw)
  144.     except Exception:
  145.         e = None
  146.         return SendFault(FaultFromException(e, 0, sys.exc_info()[2]), **kw)
  147.  
  148.  
  149.  
  150. def _ModPythonSendXML(text, code = 200, **kw):
  151.     req = kw['request']
  152.     req.content_type = 'text/xml'
  153.     req.content_length = len(text)
  154.     req.send_http_header()
  155.     req.write(text)
  156.  
  157.  
  158. def _ModPythonSendFault(f, **kw):
  159.     _ModPythonSendXML(f.AsSOAP(), 500, **kw)
  160.  
  161.  
  162. def _JonPySendFault(f, **kw):
  163.     _JonPySendXML(f.AsSOAP(), 500, **kw)
  164.  
  165.  
  166. def _JonPySendXML(text, code = 200, **kw):
  167.     req = kw['request']
  168.     req.set_header('Content-Type', 'text/xml; charset="%s"' % UNICODE_ENCODING)
  169.     req.set_header('Content-Length', str(len(text)))
  170.     req.write(text)
  171.  
  172.  
  173. def _CGISendXML(text, code = 200, **kw):
  174.     print 'Status: %d' % code
  175.     print 'Content-Type: text/xml; charset="%s"' % UNICODE_ENCODING
  176.     print 'Content-Length: %d' % len(text)
  177.     print ''
  178.     print text
  179.  
  180.  
  181. def _CGISendFault(f, **kw):
  182.     _CGISendXML(f.AsSOAP(), 500, **kw)
  183.  
  184.  
  185. class SOAPRequestHandler(BaseHTTPRequestHandler):
  186.     server_version = 'ZSI/1.1 ' + BaseHTTPRequestHandler.server_version
  187.     
  188.     def send_xml(self, text, code = 200):
  189.         self.send_response(code)
  190.         if text:
  191.             self.send_header('Content-type', 'text/xml; charset="%s"' % UNICODE_ENCODING)
  192.             self.send_header('Content-Length', str(len(text)))
  193.         
  194.         self.end_headers()
  195.         if text:
  196.             self.wfile.write(text)
  197.         
  198.         self.wfile.flush()
  199.  
  200.     
  201.     def send_fault(self, f, code = 500):
  202.         self.send_xml(f.AsSOAP(), code)
  203.  
  204.     
  205.     def do_POST(self):
  206.         
  207.         try:
  208.             ct = self.headers['content-type']
  209.             if ct.startswith('multipart/'):
  210.                 cid = resolvers.MIMEResolver(ct, self.rfile)
  211.                 xml = cid.GetSOAPPart()
  212.                 ps = ParsedSoap(xml, resolver = cid.Resolve)
  213.             else:
  214.                 length = int(self.headers['content-length'])
  215.                 ps = ParsedSoap(self.rfile.read(length))
  216.         except ParseException:
  217.             e = None
  218.             self.send_fault(FaultFromZSIException(e))
  219.             return None
  220.         except Exception:
  221.             e = None
  222.             self.send_fault(FaultFromException(e, 1, sys.exc_info()[2]))
  223.             return None
  224.  
  225.         _Dispatch(ps, self.server.modules, self.send_xml, self.send_fault, docstyle = self.server.docstyle, nsdict = self.server.nsdict, typesmodule = self.server.typesmodule, rpc = self.server.rpc)
  226.  
  227.  
  228.  
  229. def AsServer(port = 80, modules = None, docstyle = False, nsdict = { }, typesmodule = None, rpc = False, addr = ''):
  230.     address = (addr, port)
  231.     httpd = HTTPServer(address, SOAPRequestHandler)
  232.     httpd.modules = modules
  233.     httpd.docstyle = docstyle
  234.     httpd.nsdict = nsdict
  235.     httpd.typesmodule = typesmodule
  236.     httpd.rpc = rpc
  237.     httpd.serve_forever()
  238.  
  239.  
  240. def AsCGI(nsdict = { }, typesmodule = None, rpc = False, modules = None):
  241.     if os.environ.get('REQUEST_METHOD') != 'POST':
  242.         _CGISendFault(Fault(Fault.Client, 'Must use POST'))
  243.         return None
  244.     
  245.     ct = os.environ['CONTENT_TYPE']
  246.     
  247.     try:
  248.         if ct.startswith('multipart/'):
  249.             cid = resolvers.MIMEResolver(ct, sys.stdin)
  250.             xml = cid.GetSOAPPart()
  251.             ps = ParsedSoap(xml, resolver = cid.Resolve)
  252.         else:
  253.             length = int(os.environ['CONTENT_LENGTH'])
  254.             ps = ParsedSoap(sys.stdin.read(length))
  255.     except ParseException:
  256.         e = None
  257.         _CGISendFault(FaultFromZSIException(e))
  258.         return None
  259.  
  260.     _Dispatch(ps, modules, _CGISendXML, _CGISendFault, nsdict = nsdict, typesmodule = typesmodule, rpc = rpc)
  261.  
  262.  
  263. def AsHandler(request = None, modules = None, **kw):
  264.     ps = ParsedSoap(request)
  265.     kw['request'] = request
  266.     _Dispatch(ps, modules, _ModPythonSendXML, _ModPythonSendFault, **kw)
  267.  
  268.  
  269. def AsJonPy(request = None, modules = None, **kw):
  270.     kw['request'] = request
  271.     if request.environ.get('REQUEST_METHOD') != 'POST':
  272.         _JonPySendFault(Fault(Fault.Client, 'Must use POST'), **kw)
  273.         return None
  274.     
  275.     ct = request.environ['CONTENT_TYPE']
  276.     
  277.     try:
  278.         if ct.startswith('multipart/'):
  279.             cid = resolvers.MIMEResolver(ct, request.stdin)
  280.             xml = cid.GetSOAPPart()
  281.             ps = ParsedSoap(xml, resolver = cid.Resolve)
  282.         else:
  283.             length = int(request.environ['CONTENT_LENGTH'])
  284.             ps = ParsedSoap(request.stdin.read(length))
  285.     except ParseException:
  286.         e = None
  287.         _JonPySendFault(FaultFromZSIException(e), **kw)
  288.         return None
  289.  
  290.     _Dispatch(ps, modules, _JonPySendXML, _JonPySendFault, **kw)
  291.  
  292. if __name__ == '__main__':
  293.     print _copyright
  294.  
  295.